import api from '../../api';
import { message } from 'antd';
import moment from 'moment';
export default {
  namespace: 'BaselineInformationNewM',

  state: {
    benchComponents: [], // 基准信息
    complexData: [], // 复合类型的基准（包含了自定义子基准）
  },

  effects: {
    //获取表格数据
    *getTableData({ payload, callback }, { call, put }) {
      const res = yield call(api.BaselineInformationNew.queryBenchmarkPage, payload);
      if (res && res.code == '0') {
        let tempArr = [];
        if (res.data.columns && res.data.columns.length > 0) {
          tempArr = res.data.columns.filter((item) => item.dataIndex !== 'benchId');
        }
        tempArr.map((item) => {
          if (item.dataIndex !== 'weight') {
            item.render = (text, record, index) => {
              if (text === null || text === undefined) {
                return '';
              } else {
                return text;
              }
            };
          }
          if (item.dataIndex == 'updateTime') {
            item.render = (text, record, index) => {
              if (text === null || text === undefined) {
                return '';
              } else {
                return moment(text).format('YYYY-MM-DD');
              }
            };
          }
          if (item.dataIndex == 'weight') {
            item.render = (text, record, index) => {
              if (text === null) {
                return '';
              } else if (text === undefined) {
                return '--';
              } else {
                // NaN: Not a Number
                // isNaN()的缺点就在于 null、空格以及空串会被按照0来处理
                if (isNaN(text)) {
                  return text;
                } else {
                  return (Number(text) * 100).toFixed(2) + '%';
                }
              }
            };
          }
          if (item.dataIndex == 'updateBy') {
            item.align = 'left';
          }
        });
        callback('success', res.data, tempArr);
      } else {
        callback('fail');
        message.error(`获取表格数据失败，失败原因：${res?.msg}`);
        console.error(`获取表格数据失败，失败原因：${res?.msg}`, '接口名称： queryByPage 接口：benchmark/queryByPage');
      }
    },
    // 删除
    *deleteOne({ payload, callback }, { call, put }) {
      const res = yield call(api.BaselineInformationNew.deleteBenchmark, payload);
      if (res && res.code == '0') {
        message.success('删除成功');
        callback('success');
      } else {
        callback('fail');
        message.error(`删除失败，失败原因：${res?.msg}`);
        console.error(`删除失败，失败原因：${res?.msg}`, '接口名称： delete 接口：benchmark/delete');
      }
    },
    // 新增
    *addOne({ payload, callback }, { call, put }) {
      const res = yield call(api.BaselineInformationNew.createBenchmark, payload);
      if (res && res.code == '0') {
        message.success('新增成功');
        callback('success');
      } else {
        callback('fail');
        message.error(`新增失败，失败原因：${res?.msg}`);
        console.error(`新增失败，失败原因：${res?.msg}`, '接口名称： create 接口：benchmark/create');
      }
    },
    // 编辑
    *updateOne({ payload, callback }, { call }) {
      const res = yield call(api.BaselineInformationNew.modifyBenchmark, payload);
      if (res && res.code == '0') {
        message.success('编辑成功');
        callback('success');
      } else {
        callback('fail');
        message.error(`编辑失败，失败原因：${res?.msg}`);
        console.error(`编辑失败，失败原因：${res?.msg}`, '接口名称： modify 接口：benchmark/modify');
      }
    },
    // 查询基准信息
    *benchmarkComponents({ payload }, { call, put }) {
      // 判断是否是复合，complexflag=true 是复合，false 是其他类型
      let complexflag = payload.includeBench;

      const response = yield call(api.BaselineInformationNew.benchmarkComponents, payload);
      if (response && response.success) {
        let tempArr = [];
        let complexTemp = [];
        if (complexflag == 1) {
          // 复合类型
          if (response.data == null) {
            complexTemp = [];
          } else {
            complexTemp = response.data.map((item) => {
              if (item.benchId) {
                // 该条数据为自定义基准
                return { title: `【自定义】${item.name}`, value: `【自定义】${item.benchId}` };
              } else {
                return { title: `${item.name} - ${item.wind}`, value: item.wind };
              }
            });
          }
        } else {
          // 其他类型
          if (response.data == null) {
            tempArr = [];
          } else {
            tempArr = response.data.map((item) => {
              return { title: item.name, value: item.wind };
            });
          }
        }

        yield put({
          type: 'save',
          payload: {
            benchComponents: tempArr,
            complexData: complexTemp,
          },
        });
      } else {
        message.error(`查询基准信息失败，失败原因：${response?.message}`);
        console.error(`查询基准信息失败，失败原因：${response?.message}`, '接口名称： benchmarkComponents 接口：benchmark/benchmarkComponents');
      }
    },
    // 获取子基准构成数据（子基准组件使用）
    *getBenchmarkData({ payload, callback }, { call, put }) {
      // 判断是否是复合，complexflag=true 是复合，false 是其他类型
      let complexflag = payload.includeBench;

      const response = yield call(api.BaselineInformationNew.benchmarkComponents, payload);
      if (response && response.success) {
        let tempArr = [];
        let complexTemp = [];
        if (complexflag == 1) {
          // 复合类型
          if (response.data == null) {
            complexTemp = [];
          } else {
            complexTemp = response.data.map((item) => {
              if (item.benchId) {
                // 该条数据为自定义基准
                return { title: `【自定义】${item.name}`, value: item.benchId };
              } else {
                return { title: `${item.name} - ${item.wind}`, value: item.wind };
              }
            });
          }
          callback(complexTemp);
        } else {
          // 其他类型
          if (response.data == null) {
            tempArr = [];
          } else {
            tempArr = response.data.map((item) => {
              return { title: `${item.name} - ${item.wind}`, value: item.wind };
            });
          }
          callback(tempArr);
        }

        // yield put({
        //     type: 'save',
        //     payload: {
        //         benchComponents: tempArr,
        //         complexData: complexTemp,
        //     }
        // });
      } else {
        message.error(`查询基准信息失败，失败原因：${response?.message}`);
        console.error(`查询基准信息失败，失败原因：${response?.message}`, '接口名称： benchmarkComponents 接口：benchmark/benchmarkComponents');
      }
    },
    //获取用户信息
    *getUserInfo({ payload, callback }, { call, put }) {
      const response = yield call(api.BaselineInformationNew.queryCurrent, payload);
      if (response && JSON.stringify(response) != '{}' && response.success == true) {
        callback('success', response.data);
      } else {
        callback('fail');
        message.error(`获取用户信息失败，失败原因：${response?.mesg}`);
        console.error(`获取用户信息失败，失败原因：${response?.mesg}`, '接口名称： getUser 接口：user-server/usermanagement/authentication/getUser');
      }
    },
  },

  reducers: {
    save(state, { payload }) {
      return {
        ...state,
        ...payload,
      };
    },
  },
};
